package Tools;
/**
 * 整型 int 链表。
 * <p>
 * 主要功能：添加，获取，修改，删除整形数据。排序。数据转移。
 * </p>
 * <p>
 * 编写目的：为JavaME编码提供支持。
 * </p>
 * 
 * @author sodino
 * @version 1.0beta
 */
public class ArrayLink
{
	/** 默认的空间增量值。 */
	public static final int DEFAULT_INCREMENT = 7;

	/** 当前链表已存储的整形数据元素个数。 */
	private int size;

	/** 当前链表可以存储的整形数据的最多个数。 */
	private int capability;

	/** 用于存储数据的数组。 */
	private int[] array;

	/** 链表新增空间增量值。当array的长度不足时要新开辟的空间增量。 */
	private int increment;

	/** 标识ArrayLink是否排序过。“0”表示未排序过，“-1”表示现在处于降序排序，“1”表示现在处于升序排序。 */
	private int isSorted;

	/**
	 * 构造一个空链表。
	 */
	public ArrayLink()
	{
		size = 0;
		increment = DEFAULT_INCREMENT;
		capability = DEFAULT_INCREMENT;
		array = new int[capability];
		isSorted = 0;
	}

	/**
	 * 构造一个空链表，该链表的初始容量为设定的capability大小。
	 * 
	 * @param capability -
	 *            该链表的初始容量值。
	 * @param increment -
	 *            自设置的容量增量值。
	 */
	public ArrayLink(int capability, int increment)
	{

		this.capability = Math.max(capability, DEFAULT_INCREMENT);
		size = 0;
		this.increment = Math.max(increment, DEFAULT_INCREMENT);
		array = new int[this.capability];
		isSorted = 0;
	}

	/**
	 * 构造一个ArrayLink,并将指定的整形数组添加进新构造的ArrayLink。
	 * 
	 * @param arrs -
	 *            指定的待添加的数组。
	 */
	public ArrayLink(int[] arrs)
	{
		size = arrs.length;
		capability = Math.max(size, DEFAULT_INCREMENT);
		array = new int[capability];
		for (int i = 0; i < size; i++)
		{
			array[i] = arrs[i];
		}
		isSorted = 0;
	}

	/**
	 * 为ArrayLink添加新的整形数据。
	 * 
	 * @param value -
	 *            新添加的数据。
	 * @return 添加成功返回true，失败返回false。
	 */
	public boolean add(int value)
	{
		confirmCapability(size() + 1);
		array[size()] = value;
		setSize(size() + 1);
		isSorted = 0;
		// System.out.println("add: " + value);
		return true;
	}

	/**
	 * 将arr数组中的数据全部添加进ArrayLink中。
	 * 
	 * @param arr -
	 *            待添加的数据数组。
	 * @return 添加成功返回true，失败返回false。
	 */
	public boolean add(int[] arr)
	{
		if (arr == null)
		{
			return false;
		}
		if (arr.length == 0)
		{
			return true;
		}
		confirmCapability(size() + arr.length);
		for (int i = 0; i < arr.length; i++)
		{
			add(arr[i]);
		}
		return true;
	}

	/**
	 * 将link链表中的数据全部添加进ArrayLink中。
	 * 
	 * @param link -
	 *            待添加的数据数组。
	 * @return 添加成功返回true，失败返回false。
	 */
	public boolean add(ArrayLink link)
	{
		if (link == null)
		{
			return false;
		}
		if (link.size() == 0)
		{
			return true;
		}
		confirmCapability(size() + link.size());
		for (int i = 0; i < link.size(); i++)
		{
			add(link.get(i));
		}
		return true;
	}

	/**
	 * 删除指定序号的数据。
	 * 
	 * @param index -
	 *            指定要删除的数据的序号。
	 * @return 删除成功返回true，失败返回false。
	 */
	public boolean remove(int index)
	{
		return remove(index, 1);
	}

	/**
	 * 删除从startIndex开始，长度为length的数据。
	 * 
	 * @param startIndex -
	 *            开始删除的数据的序号。
	 * @param length -
	 *            删除的数据的长度。
	 * @return 删除成功返回true；反之返回false。
	 */
	public boolean remove(int startIndex, int length)
	{
		// 如果删除区域与已存储区域两者之间没有生命的区间，删除失败。
		if (startIndex < 0)
		{
			return false;
		}
		if (startIndex > size() - 1)
		{
			return false;
		}
		if (length <= 0)
		{
			return false;
		}
		int firstMoveIndex = startIndex + length;
		if (firstMoveIndex > size() - 1)
		{
			size = startIndex;
			// System.out.println("directly");
			return false;
		}
		int moveCount = size() - startIndex - length;
		int endIndex = startIndex + moveCount;
		for (int i = startIndex; i < endIndex; i++)
		{
			array[i] = array[i + length];
		}
		setSize(size - length);
		return true;
	}

	/**
	 * 更改指定序号的数据为指定的data。
	 * 
	 * @param index -
	 *            指定修改的数据的序号。
	 * @param data -
	 *            修改后的值。
	 * @return 修改成功返回true，失败返回false。
	 */
	public boolean modify(int index, int data)
	{
		if (index < 0 || index > size() - 1)
		{
			return false;
		}
		array[index] = data;
		isSorted = 0;
		return true;
	}

	/**
	 * 获取指定的序号的数据。
	 * 
	 * @param index -
	 *            指定的序号。
	 * @return 当index小于等于size时，返回指定的序号的数据值；如果大于index值，返回0。
	 */
	public int get(int index)
	{
		if (index > size() - 1 || index < 0)
		{
			return 0;
		}
		return array[index];
	}

	/**
	 * 一次性增加本链表的容量。
	 * 
	 * @param increment -
	 *            新增加的容量值。
	 * @return 容量增加成功返回true，失败返回false。
	 */
	public boolean addCapability(int increment)
	{
		if (increment <= 0)
		{
			return false;
		}
		int newCapability = this.getCapability() + increment;
		int[] newArr = new int[newCapability];
		this.capability = newCapability;
		System.arraycopy(array, 0, newArr, 0, array.length);
		array = null;
		array = newArr;
		// System.out.println("addCapabilityValue:" + increment);
		return true;
	}

	/**
	 * 减少ArrayLink的容量值。无论减少值为多少，ArrayLink都保留DEFAULT_INCREMENT大小的最小容量。
	 * 
	 * @param decrement -
	 *            容量值的减少量。
	 * @return 容量减少成功返回true，失败返回false。
	 */
	public boolean reduceCapability(int decrement)
	{
		if (decrement <= 0)
		{
			return false;
		}
		int maxDecrement = getCapability() - DEFAULT_INCREMENT;
		if (decrement > maxDecrement)
		{
			decrement = maxDecrement;
		}
		int newCapability = getCapability() - decrement;
		int[] newArr = new int[newCapability];
		this.capability = newCapability;
		setSize(Math.min(size(), newCapability));
		int copyLength = size();
		System.arraycopy(array, 0, newArr, 0, copyLength);
		// System.out.println("newCap: " + this.getCapability() +
		// "copyLength: "
		// + copyLength);
		array = null;
		array = newArr;
		return true;
	}

	/**
	 * <p>
	 * 将源ArrayLink中从src_position开始的数据内容原封不动地转移长度为length的数据量到
	 * 目的ArrayLink中以dist_position开始的位置中。
	 * </p>
	 * <p>
	 * 如果目的ArrayLink的容量不够，将扩展充目的ArrayLink的容量。 目的ArrayLink中的存储的数据从dist_position ~
	 * dist_position + length区间将被改变。
	 * </p>
	 * 
	 * @param src -
	 *            源ArrayLink，被复制数据源。
	 * @param src_position -
	 *            源ArrayLink中被复制的起始序号。
	 * @param dist -
	 *            目的ArrayLink,数据复制目的地。
	 * @param dist_position -
	 *            目的ArrayLink中被复制的起始序号。
	 * @param length -
	 *            转移的数据长度。
	 * @return 数据转移成功返回true，反之返回false。
	 */
	public static final boolean copyArrayLink(ArrayLink src, int src_position, ArrayLink dist, int dist_position, int length)
	{
		if (length > src.size())
		{
			return false;
		}
		if (src_position > src.size() - 1)
		{
			return false;
		}
		int distCapability = dist.getCapability();
		// ????
		int sub = dist_position + length - distCapability;
		if (sub > 0)
		{
			dist.addCapability(sub);
		}
		System.arraycopy(src.array, src_position, dist.array, dist_position, length);
		int newDistSize = Math.max(dist.size(), dist_position + length);
		dist.setSize(newDistSize);
		dist.isSorted = 0;
		return true;

	}

	/**
	 * 获取当前链表可以存储的整形数据的最多个数。
	 * 
	 * @return 当前链表可以存储的整形数据的最多个数。
	 */
	public int getCapability()
	{
		return capability;
	}

	/**
	 * 返回当前链表忆存储的整形数据个数。
	 * 
	 * @return 当前链表忆存储的整形数据个数。
	 */
	public int size()
	{
		return size;
	}

	/**
	 * 设置新的size值。
	 * 
	 * @param size -
	 *            新的size值。
	 */
	private void setSize(int size)
	{
		this.size = size;
	}

	/**
	 * 获取当前链表的剩余容量。
	 * 
	 * @return 当前链表的剩余容量。
	 */
	public int remainingCapability()
	{
		return getCapability() - size();
	}

	/**
	 * 设置空间增量值。增量最小值默认为DEFAULT_INCREMENT。
	 */
	public void setIncrement(int increment)
	{
		this.increment = Math.max(increment, DEFAULT_INCREMENT);
	}

	/**
	 * 获取空间增量值。
	 * 
	 * @return 空间增量值。
	 */
	public int getIncrement()
	{
		return increment;
	}

	/**
	 * <p>
	 * 确认当前的ArrayLink是否可以存储size大小的数据量。
	 * </p>
	 * <p>
	 * 如果不足以存储size大小的数据量，ArrayLink将自动增加increment大小的空间。
	 * </p>
	 * 
	 * @param size -
	 *            待验证的容量。
	 */
	private void confirmCapability(int size)
	{
		int sub = size - getCapability();
		if (sub > 0)
		{
			// 空间不足
			// System.out.println("Capability is Inadequate!");
			int incre = Math.max(increment, sub);
			addCapability(incre);
		}
	}

	/**
	 * 按指定的排序规则进行排序。
	 * 
	 * @param ascent -
	 *            true表示排序顺序为升序，false表示排序顺序为降序。
	 */
	public void sort(boolean ascent)
	{
		// 冒泡排序
		boolean exchanged = true;
		int bottom = size() - 1;
		while (exchanged)
		{
			exchanged = false;
			for (int i = 0; i < bottom; i++)
			{
				if (ascent)
				{
					if (array[i] > array[i + 1])
					{
						int temp = array[i];
						array[i] = array[i + 1];
						array[i + 1] = temp;
						exchanged = true;
					}
				} else
				{
					if (array[i] < array[i + 1])
					{
						int temp = array[i];
						array[i] = array[i + 1];
						array[i + 1] = temp;
						exchanged = true;
					}
				}
			}
			bottom--;
		}
		if (ascent == true)
		{
			isSorted = 1;
		} else
		{
			isSorted = -1;
		}
	}

	/**
	 * 获取当前的ArrayLink是否排好序了。
	 * 
	 * @return 返回“0”表示未排序过，返回“-1”表示现在处于降序排序，返回“1”表示现在处于升序排序。
	 */
	public int isSorted()
	{
		return isSorted;
	}

	/**
	 * 删除所有的数据。
	 */
	public void clear()
	{
		setSize(0);
		isSorted = 0;
	}

	public int[] getArray(ArrayLink lin)
	{
		ArrayLink link = new ArrayLink();
		for (int i = 0; i < lin.size(); i++)
		{
			if (lin.get(i) > 0)
			{
				link.add(lin.get(i));
			}
		}
		int ar[] = new int[link.size()];
		for (int i = 0; i < ar.length; i++)
		{
			ar[i] = link.get(i);
		}
		return ar;
	}

	public int[] getArray()
	{
		return array;
	}

	public void removeAllelement()
	{
		remove(0, array.length);
	}

	public static short Stonepacket[] =
	// 宝石 暂时的

	// 0 生命宝石 1能量宝石,2保护宝石// 3力量宝石 4暴击宝石 5吸血宝石 6恢复宝石
	{

	0, 1,

	1, 1,

	2, 1,

	3, 1,

	4, 1,

	5, 1,

	6, 1,

	};

	public static void addGood(int type, short goodsArray[], int num)
	{
		int index = 0;
		while (true)
		{
			if (type == goodsArray[index << 1])
			{
				goodsArray[(index << 1) + 1] += num;
				break;
			} else
			{
				if (goodsArray[index << 1] == -1)
				{
					goodsArray[index << 1] = (short) type;
					goodsArray[(index << 1) + 1] += num;
					break;
				}
			}

			index++;
			if (index > (goodsArray.length >> 1) - 1)
			{
				break;
			}
		}

		for (int i = 0; i < goodsArray.length >> 1; i++)
		{
			System.out.print(goodsArray[i << 1] + " ");
			System.out.println(goodsArray[(i << 1) + 1]);
		}

	}

	public static void delectGood(int type, short goodsArray[], int num)
	{

		int index = 0;
		while (true)
		{
			if (type == goodsArray[index << 1])
			{
				goodsArray[(index << 1) + 1] -= num;
				if (goodsArray[(index << 1) + 1] == 0)
				{
					goodsArray[(index << 1) + 0] = -1;
					for (int i = index; i < (goodsArray.length >> 1) - 1; i++)
					{
						goodsArray[(i) << 1] = goodsArray[(i + 1) << 1];
						goodsArray[(i << 1) + 1] = goodsArray[((i + 1) << 1) + 1];
					}
					goodsArray[((goodsArray.length >> 1) - 1) << 1] = -1;
					goodsArray[(((goodsArray.length >> 1) - 1) << 1) + 1] = -1;
				}
				break;
			}
			index++;
			if (index > (goodsArray.length >> 1) - 1)
			{
				break;
			}
		}
	}
	
	public static int stone[]=
	
	{
		
		0,1,
		
		0,1,
		
		2,0,
		
		3,2,
		
		5,0,
		
		3,0,
		
		5,0,
		
		4,1
		
	};
	public static int getStoneNum(int type, int level)
	{
		int index = 0;
		int num = 0;
		while (true)
		{
			if (type == stone[index << 1] && stone[(index << 1) + 1] == level)
			{
				num++;
			}
			index++;
			if (index > (stone.length >> 1) - 1)
			{
				break;
			}
		}

		return num;
	}

	public static void main(String args[])
	{
//		System.out.println(getStoneNum(5,0));
		   String aa[]={"11","cc","22","bb","33","cc","44","dd","55","ee","66","ff","77","gg","88","hh","99","ii","1010","jj"};
		   
		   for(int i=0;i<(aa.length>>1);i++)
		   {
			   System.out.print(aa[(i<<1)]+"  ");
			   System.out.println(aa[(i<<1)+1]);
		   }
	}
	// ArrayLink arrayLink = new ArrayLink();
	// arrayLink.add(2);
	// arrayLink.add(3);
	// arrayLink.add(3);
	// arrayLink.add(4);
	// arrayLink.add(4);
	// arrayLink.add(4);
	// arrayLink.add(4);
	// arrayLink.add(new int[]
	// { 1, 2, 3, 4, 5, 6, 8, 9 });
	// for (int i = 0; i < arrayLink.getArray().length; i++)
	// {
	// System.out.println(arrayLink.getArray()[i]);
	// }
	// System.out.println("______________");
	// arrayLink.removeAllelement();
	// System.out.println(arrayLink.getArray().length);
	// for(int i=0;i<arrayLink.size();i++)
	// {
	// System.out.println(arrayLink.getArray()[i]);
	// }

	// }
}
// package sodino.output;
// /**
// * @author sodino
// */
// public class ArrayLinkTest {
// public static void main(String[] args) {
// // 测试remove(int,int)
// ArrayLink al = new ArrayLink();
// for (int i = 0; i < 20; i++) {
// al.add(i);
// }
// for (int i = 0; i < al.size(); i++) {
// System.out.print(al.get(i) + ", ");
// }
// System.out.println();
// for (int i = 0; i < 20; i++) {
// System.out
// .print("remove index:" + 0 + " value:" + al.get(0) + " ");
// al.remove(0);
// for (int j = 0; j < al.size(); j++) {
// System.out.print(al.get(j) + " ");
// }
// System.out.println();
// }
// System.out.println("after removeal.size:" + al.size());
// for (int i = 0; i < al.size(); i++) {
// System.out.print(al.get(i) + " ");
// }
// System.out.println("endal.size:" + al.size());
// 测试modify()
// ArrayLink al = new ArrayLink();
// for (int i = 0; i < 20; i++) {
// java.util.Random random = new java.util.Random();
// int ran = random.nextInt();
// al.add(ran);
// }
// System.out.println(al.modify(-1, 0) + " " + al.get(-1));
// System.out.println(al.modify(0, 111) + " " + al.get(0));
// System.out.println(al.modify(19, 111) + " " + al.get(19));
// System.out.println(al.modify(20, 111) + " " + al.get(20));

// 测试sort()
// ArrayLink al = new ArrayLink();
// for (int i = 0; i < 100; i++) {
// java.util.Random random = new java.util.Random();
// int ran = random.nextInt();
// al.add(ran);
// }
// al.sort(false);
// for (int i = 0; i < al.size(); i++) {
// System.out.println(i + ": " + al.get(i));
// }
// System.out.println("end al.size:" + al.size() + " al.cap:"
// + al.getCapability());
// 测试remove()
// ArrayLink al = new ArrayLink();
// for (int i = 0; i < 20; i++) {
// al.add(i);
// }
// System.out.println("after all add,al.size: " + al.size());
// for (int i = 19; i >= 0; i--) {
// al.remove(i);
// }
//   
// System.out.println("after all remove,al.size: " + al.size());
// 测试add()及addCapability()及confirmCapability()
// ArrayLink al1 = new ArrayLink(0, 1);
// ArrayLink al2 = new ArrayLink(0, 1);
// for (int i = 0; i < 15; i++) {
// al1.add(i);
// }
// System.out.println("after allAdd size:" + al1.size() + "cap:"
// + al1.getCapability());
// System.out.println("add Over");
// al1.reduceCapability(20);
// for (int i = 0; i < al1.size(); i++) {
// System.out.print(al1.get(i) + " ");
// }
// System.out.println();
// System.out.println(al1.size() + " end");

// 测试ArrayLink.copyArrayLink()
// int[] arr = { 1, 2, 3, 4, 5, 6 };
// int[] arr1 = {};
// ArrayLink al = new ArrayLink(arr);
// ArrayLink al1 = new ArrayLink(arr1);
// ArrayLink.copyArrayLink(al, 0, al1, 1, al.size());
// for (int i = 0; i < al1.size(); i++) {
// System.out.print(al1.get(i) + " ");
// }
// System.out.println("end " + al1.size());
// 测试读取
// for (int i = 0; i < al.size(); i++) {
// System.out.print(al.get(i) + " ");
// }
// }
// }
